package com.ccn.ui.lsn12animator;


import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.PropertyValuesHolder;
import android.animation.TypeEvaluator;
import android.animation.ValueAnimator;
import android.app.Activity;
import android.graphics.PointF;
import android.os.Bundle;

import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.AnticipateInterpolator;
import android.view.animation.AnticipateOvershootInterpolator;
import android.view.animation.BounceInterpolator;
import android.view.animation.CycleInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.LinearInterpolator;
import android.view.animation.OvershootInterpolator;
import android.widget.FrameLayout;

import com.ccn.ui.R;

/**
 * 属性动画，API3.0之后提出的动画模式
 * 优点：
 * 1.不在局限于View 对象，无对象也可以进行动画处理
 * 2.不再局限于4种基本变换：平移、旋转、缩放 、透明度
 * 3.可以灵活的操作任意对象属性，根据自己业务来实现自己想要的结果
 * 核心：
 * 1.ObjectAnimator  对象动画（重点）
 * 2.ValueAnimator	  值动画(重点)
 * 3.PropertyValueHolder 用于多个动画同时执行
 * 4.TypeEvaluator 估值器
 * 6.AnimatorSet 动画集合
 * 5.Interpolator 插值器
 */
public class MainActivity extends Activity {

    private View iv;
    private FrameLayout mMainView;
    private SplashView splashView;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_lsn12_main);
        iv = findViewById(R.id.img_iv);


        //将动画层盖在实际的操作图层上
        /*mMainView = new FrameLayout(this);
        ContentView contentView = new ContentView(this);
        mMainView.addView(contentView);
        splashView = new SplashView(this);
        mMainView.addView(splashView);

        setContentView(mMainView);

        //后台开始加载数据
        startLoadData();*/


    }

    //    ------------------------加载动画--------------------------------------
    Handler handler = new Handler();

    private void startLoadData() {
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                //数据加载完毕，进入主界面--->开启后面的两个动画
                splashView.splashDisappear();
            }
        }, 5000);//延迟时间
    }


//    ------------------------基础案例--------------------------------------

    public void startAnimator(View view) {

        switch (view.getId()) {
            case R.id.btn_object:
                startObjectAnimatorAnim(iv);
                break;
            case R.id.btn_animatorset:
                startAnimatorSet(iv);
                break;
            case R.id.btn_value:
                startValueAnimatorAnim(view);
                break;
            case R.id.btn_interpolator:
                startInterpolatorApply(iv);
                break;
            case R.id.btn_valueholder:
                startPropertyValueHolderAnim(iv);
                break;
            case R.id.btn_evaluator:
                startEvaluator(iv);
                break;
        }


    }


    /**
     * 操作对象属性，不局限于对象
     * 完成透明动画
     *
     * @param v
     */
    public void startObjectAnimatorAnim(View v) {
//        200 1-0.3

        //1.设置参数
        //2.执行动画
        ObjectAnimator alphaAnim = ObjectAnimator.ofFloat(v, "alpha", 1.0f, 0.3f, 1.0f);
        alphaAnim.setDuration(1000);//执行时间
        alphaAnim.setStartDelay(300);//延迟
        alphaAnim.start();


    }


    /**
     * @param v
     */
    public void startValueAnimatorAnim(final View v) {
        //组合使用300
        ObjectAnimator animator = ObjectAnimator.ofFloat(v, "hehe", 0f, 100f, 50f);

        animator.setDuration(300);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

            @Override
            public void onAnimationUpdate(ValueAnimator animation) {

//				animation.getAnimatedFraction();//百分比
                float value = (float) animation.getAnimatedValue();//百分比的所对应的值
                v.setScaleX(0.5f + value / 200);
                v.setScaleY(0.5f + value / 200);

            }
        });
        animator.start();
//		animator.setRepeatCount(2);//重复次数
//		animator.setRepeatCount(ValueAnimator.INFINITE);//无限次数


    }

    public void startPropertyValueHolderAnim(View v) {
        PropertyValuesHolder holder1 = PropertyValuesHolder.ofFloat("alpha", 1f, 0.5f);
        PropertyValuesHolder holder2 = PropertyValuesHolder.ofFloat("scaleX", 1f, 0.5f);
        PropertyValuesHolder holder3 = PropertyValuesHolder.ofFloat("scaleY", 1f, 0.5f);
        ObjectAnimator animator = ObjectAnimator.ofPropertyValuesHolder(v, holder1, holder2, holder3);
        animator.setDuration(200);
        animator.start();

    }


    public void startAnimatorSet(View v) {
        //移动动画
        ObjectAnimator animator1 = ObjectAnimator.ofFloat(iv, "translationX", 0f, 500F);
        //透明度动画
        ObjectAnimator animator2 = ObjectAnimator.ofFloat(iv, "alpha", 1.0f, 0f, 1f);
        //缩放动画
        ObjectAnimator animator3 = ObjectAnimator.ofFloat(iv, "scaleX", 1f, 2f);
        AnimatorSet animatorSet = new AnimatorSet();
        animatorSet.setDuration(1500);

        /*
        public Builder with(Animator anim) 和前面动画一起执行
        public Builder before(Animator anim) 执行前面的动画后再执行该动画
        public Builder after(Animator anim) 先执行这个动画再执行前面动画
        public Builder after(long delay) 延迟n毫秒之后执行动画*/
//        animatorSet.play(animator3).with(animator2).after(animator1);//链式调用顺序
        //animatorSet.play(animator3).with(animator2).before(animator1);//animator1
        //animatorSet.playTogether(animator1,animator2,animator3);//一起执行
        animatorSet.playSequentially(animator1, animator2, animator3);//顺序执行
        /*
        animator2，animator1均在animator3之后执行，
        相当于执行完animator3，animator2和animator1一起执行。
        * */
//        animatorSet.play(animator3).before(animator2).before(animator1);
        animatorSet.start();
    }


    /**
     * 估值器
     * 自由落体效果实现
     * 核心目的：自定义变换规则
     * <p>
     * Evaluator用于将从插值器（Interpolator）返回的数值进度转换为对应的数值。
     *
     * @param v
     */
    public void startEvaluator(final View v) {
        ValueAnimator animator = new ValueAnimator();
        animator.setDuration(3000);
        /*
        setObjectValues 只有一个参数new PointF(0, 0)
        startValue null
        endValue   PointF(0.0, 0.0)
        setObjectValues 只有两个参数new PointF(0, 0) new PointF(100,100)
        startValue PointF(0.0, 0.0)
        endValue   PointF(100.0, 100.0)
        setObjectValues 只有三个参数new PointF(0, 0),new PointF(50,50),new PointF(100,100)
        执行两次动画！！！
        第一次：
        startValue PointF(0.0, 0.0)
        endValue   PointF(50.0, 50.0)
        第二次：
        startValue PointF(50.0, 50.0)
        endValue   PointF(100.0,100.0)
         */
        animator.setObjectValues(new PointF(0, 0), new PointF(50, 50), new PointF(100, 100));
        final PointF point = new PointF();
        //估值
        animator.setEvaluator(new TypeEvaluator() {
            /**
             * ① 参数 fraction ：进度 就是插值器中的返回值，表示当前动画的数值进度
             *
             * ② 参数 startValue：开始数值（例子中的0）
             *
             * ③ 参数endValue：结束数值（例子中的100）
             */
            @Override
            public Object evaluate(float fraction, Object startValue, Object endValue) {
                point.x = 100f * (fraction * 5);
                // y=vt=1/2*g*t*t(重力计算)
                point.y = 0.5f * 130f * (fraction * 5) * (fraction * 5);

                Log.e("TAG", fraction + "evaluate: " + String.valueOf(startValue) + "--" + String.valueOf(endValue));

                return point;
            }
        });

        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                PointF p = (PointF) animation.getAnimatedValue();
                v.setX(p.x);
                v.setY(p.y);
            }
        });
        animator.start();
    }

    /**
     * 插值器
     * 由API提供的一组算法，用来操作动画执行是的变换规则，省去了一些自己写算法的麻烦，大致分为九种
     *
     * @param v
     */
    public void startInterpolatorApply(final View v) {
        ValueAnimator animator = new ValueAnimator();
        animator.setDuration(3000);
        animator.setObjectValues(new PointF(0, 0));
        final PointF point = new PointF();
        //估值
        animator.setEvaluator(new TypeEvaluator() {
            @Override
            public Object evaluate(float fraction, Object startValue, Object endValue) {
                point.x = 100f * (fraction * 5);
                // y=vt=1/2*g*t*t(重力计算)
                point.y = 0.5f * 98f * (fraction * 5) * (fraction * 5);
                return point;
            }
        });

        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                PointF pointF = (PointF) animation.getAnimatedValue();
                v.setX(pointF.x);
                v.setY(pointF.y);
            }
        });


        //详细算法见资料图片
//		加速插值器，公式： y=t^(2f) （加速度参数. f越大，起始速度越慢，但是速度越来越快）
//        animator.setInterpolator(new AccelerateInterpolator(10));

//      减速插值器公式: y=1-(1-t)^(2f) （描述: 加速度参数. f越大，起始速度越快，但是速度越来越慢）
//		animator.setInterpolator(new DecelerateInterpolator());

//      先加速后减速插值器 y=cos((t+1)π)/2+0.5
//		animator.setInterpolator(new AccelerateDecelerateInterpolator());

//      张力值, 默认为2，T越大，初始的偏移越大，而且速度越快 公式：y=(T+1)×t3–T×t2
//		animator.setInterpolator(new AnticipateInterpolator());

//      张力值tension，默认为2，张力越大，起始和结束时的偏移越大，
//      而且速度越快;额外张力值extraTension，默认为1.5。公式中T的值为tension*extraTension
//		animator.setInterpolator(new AnticipateOvershootInterpolator());
//      弹跳插值器
        animator.setInterpolator(new BounceInterpolator());
//      周期插值器 y=sin(2π×C×t)  周期值，默认为1；2表示动画会执行两次
//		animator.setInterpolator(new CycleInterpolator(2));
//		线性插值器，匀速公式：Y=T
//		animator.setInterpolator(new LinearInterpolator());

//      公式: y=(T+1)x(t1)3+T×(t1)2 +1
//      描述: 张力值，默认为2，T越大，结束时的偏移越大，而且速度越快
//		animator.setInterpolator(new OvershootInterpolator());

        animator.start();

    }

}
